```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>现代并发编程指南 - 从多线程到高性能</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 50%, #d946ef 100%);
        }
        .code-block {
            background-color: #1e293b;
            border-left: 4px solid #8b5cf6;
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-4px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight-word {
            background: linear-gradient(120deg, #a5b4fc 0%, #a5b4fc 100%);
            background-repeat: no-repeat;
            background-size: 100% 40%;
            background-position: 0 88%;
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 4.5rem;
            line-height: 0.65;
            margin: 0.1em 0.1em 0.2em 0;
            color: #6366f1;
            font-weight: bold;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-4xl mx-auto text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">
                现代<span class="highlight-word">并发编程</span>的艺术
            </h1>
            <p class="text-xl md:text-2xl mb-8 opacity-90 leading-relaxed">
                探索多线程编程的奥秘，构建高性能应用程序的核心技术
            </p>
            <div class="flex justify-center space-x-4">
                <a href="#concepts" class="px-6 py-3 bg-white text-indigo-600 font-semibold rounded-lg shadow-md hover:bg-gray-100 transition duration-300">
                    <i class="fas fa-book mr-2"></i>开始学习
                </a>
                <a href="#visualization" class="px-6 py-3 bg-opacity-20 bg-white text-white font-semibold rounded-lg hover:bg-opacity-30 transition duration-300">
                    <i class="fas fa-project-diagram mr-2"></i>可视化探索
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <p class="text-lg leading-relaxed text-gray-700 mb-6 drop-cap">
                并发编程是现代程序设计中的一个重要领域，它允许程序同时执行多个任务，从而提升应用程序的性能和响应能力。多线程编程是实现并发编程的一种常用技术，尤其在处理高并发请求和计算密集型任务时，它能显著提升程序的效率。然而，编写并发程序并不容易，特别是在多线程环境下，如何确保线程安全、避免死锁和竞态条件，成为了程序员面临的重要问题。
            </p>
            <div class="grid md:grid-cols-2 gap-8 mt-10">
                <div class="bg-white p-6 rounded-xl shadow-md border border-gray-100 card-hover">
                    <div class="flex items-center mb-4">
                        <div class="bg-indigo-100 p-3 rounded-full mr-4">
                            <i class="fas fa-bolt text-indigo-600 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold text-gray-800">为什么选择多线程？</h3>
                    </div>
                    <p class="text-gray-600">多线程可以充分利用多核CPU的性能，提高程序响应速度，是现代高性能应用的基石。在I/O密集型和计算密集型任务中都能带来显著的性能提升。</p>
                </div>
                <div class="bg-white p-6 rounded-xl shadow-md border border-gray-100 card-hover">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-3 rounded-full mr-4">
                            <i class="fas fa-exclamation-triangle text-purple-600 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold text-gray-800">面临的挑战</h3>
                    </div>
                    <p class="text-gray-600">线程安全、死锁、竞态条件等问题是多线程编程中的常见挑战。理解这些问题的本质并掌握应对策略是成为高级开发者的必经之路。</p>
                </div>
            </div>
        </section>

        <!-- Section 1 -->
        <section id="concepts" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">1. 并发与多线程的基本概念</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div class="space-y-6">
                    <div>
                        <h3 class="text-xl font-semibold text-gray-800 mb-3 flex items-center">
                            <span class="bg-indigo-100 text-indigo-800 px-3 py-1 rounded-full mr-3 text-sm">1.1</span>
                            并发的定义
                        </h3>
                        <p class="text-gray-700 leading-relaxed">
                            并发指的是一个程序能够在多个任务之间进行切换执行，给用户带来"同时执行"的错觉。并发并不要求任务真正同时执行，而是能够有效地在多个任务之间切换，利用 CPU 的空闲时间来执行其他任务，进而提升系统的吞吐量和响应速度。
                        </p>
                    </div>
                    <div class="bg-indigo-50 p-4 rounded-lg border-l-4 border-indigo-400">
                        <div class="flex">
                            <i class="fas fa-info-circle text-indigo-500 mt-1 mr-3"></i>
                            <p class="text-indigo-800">
                                <strong>关键点：</strong> 并发强调的是任务的逻辑"同时"执行，而非物理上的并行执行。
                            </p>
                        </div>
                    </div>
                </div>

                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-3 flex items-center">
                        <span class="bg-purple-100 text-purple-800 px-3 py-1 rounded-full mr-3 text-sm">1.2</span>
                        多线程的定义
                    </h3>
                    <p class="text-gray-700 leading-relaxed mb-4">
                        多线程是并发编程的一种实现方式。一个进程可以包含多个线程，每个线程都是程序中的独立执行单元，线程之间共享同一进程的资源。多线程能够充分利用多核 CPU 的优势，实现更高效的任务处理。每个线程可以执行独立的任务，线程之间可以并行或并发地执行。
                    </p>
                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-200">
                        <div class="flex items-center text-sm">
                            <i class="fas fa-code text-gray-400 mr-2"></i>
                            <span class="font-mono text-gray-600">Thread vs Process: 线程比进程更轻量级，创建和切换开销更小</span>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Visualization Section -->
        <section id="visualization" class="mb-16 bg-white p-6 rounded-xl shadow-md">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-purple-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">并发模型可视化</h2>
            </div>
            
            <div class="mermaid">
                graph TD
                    A[并发编程] --> B[多线程]
                    A --> C[协程]
                    A --> D[异步编程]
                    B --> E[线程创建]
                    B --> F[线程同步]
                    B --> G[线程池]
                    E --> H[继承Thread类]
                    E --> I[实现Runnable接口]
                    F --> J[synchronized]
                    F --> K[Lock]
                    F --> L[Atomic]
                    G --> M[Executor框架]
                    G --> N[线程池配置]
                    style A fill:#6366f1,color:white,stroke:#4f46e5
                    style B fill:#8b5cf6,color:white,stroke:#7c3aed
            </div>
            
            <div class="mt-6 text-sm text-gray-500">
                <i class="fas fa-mouse-pointer mr-2"></i>点击图表中的元素可展开查看详细关系
            </div>
        </section>

        <!-- Section 2 -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-pink-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">2. 多线程的优势与挑战</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-green-100 text-green-800 px-3 py-1 rounded-full mr-3 text-sm">2.1</span>
                        多线程的优势
                    </h3>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <div class="bg-green-100 p-1 rounded-full mr-3 mt-1">
                                <i class="fas fa-check text-green-600 text-xs"></i>
                            </div>
                            <span class="text-gray-700"><strong>提高响应性：</strong>在多线程环境下，程序能够同时处理多个任务，避免了阻塞的情况。例如，GUI 程序中的事件处理与后台任务可以在不同的线程中并行进行。</span>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-green-100 p-1 rounded-full mr-3 mt-1">
                                <i class="fas fa-check text-green-600 text-xs"></i>
                            </div>
                            <span class="text-gray-700"><strong>提高资源利用率：</strong>多线程能够充分利用多核 CPU，进行任务的并行处理，提升系统的整体性能。</span>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-green-100 p-1 rounded-full mr-3 mt-1">
                                <i class="fas fa-check text-green-600 text-xs"></i>
                            </div>
                            <span class="text-gray-700"><strong>提高吞吐量：</strong>在处理大量 I/O 密集型任务时，多线程能够有效地减少等待时间，提升系统的吞吐量。</span>
                        </li>
                    </ul>
                </div>

                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-red-100 text-red-800 px-3 py-1 rounded-full mr-3 text-sm">2.2</span>
                        多线程的挑战
                    </h3>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <div class="bg-red-100 p-1 rounded-full mr-3 mt-1">
                                <i class="fas fa-exclamation text-red-600 text-xs"></i>
                            </div>
                            <span class="text-gray-700"><strong>线程安全问题：</strong>多个线程共享同一资源时，可能会导致资源竞争，从而引发线程安全问题。例如，多个线程同时访问同一变量可能会导致数据不一致。</span>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-red-100 p-1 rounded-full mr-3 mt-1">
                                <i class="fas fa-exclamation text-red-600 text-xs"></i>
                            </div>
                            <span class="text-gray-700"><strong>死锁：</strong>如果两个或多个线程在执行时相互等待对方释放资源，可能导致程序陷入死锁，无法继续执行。</span>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-red-100 p-1 rounded-full mr-3 mt-1">
                                <i class="fas fa-exclamation text-red-600 text-xs"></i>
                            </div>
                            <span class="text-gray-700"><strong>上下文切换开销：</strong>虽然多线程能够并行执行任务，但频繁的线程上下文切换也会带来性能开销，尤其是在高并发的情况下。</span>
                        </li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Section 3 -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-blue-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">3. 线程的创建与管理</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-blue-100 text-blue-800 px-3 py-1 rounded-full mr-3 text-sm">3.1</span>
                        创建线程的方式
                    </h3>
                    <p class="text-gray-700 mb-4">
                        在 Java 中，线程可以通过两种方式创建：
                    </p>
                    
                    <div class="mb-6">
                        <div class="flex items-center mb-2">
                            <div class="bg-blue-500 w-3 h-3 rounded-full mr-2"></div>
                            <h4 class="font-medium text-gray-800">继承 Thread 类</h4>
                        </div>
                        <p class="text-gray-600 text-sm mb-2">通过继承 <code>Thread</code> 类并重写 <code>run()</code> 方法，来定义线程的执行任务。</p>
                        <div class="code-block p-4 rounded-lg mb-4">
                            <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-purple-300">class</span> <span class="text-blue-300">MyThread</span> <span class="text-purple-300">extends</span> <span class="text-blue-300">Thread</span> {
    <span class="text-blue-300">@Override</span>
    <span class="text-purple-300">public</span> <span class="text-blue-300">void</span> <span class="text-yellow-300">run</span>() {
        <span class="text-blue-300">System</span>.<span class="text-yellow-300">out</span>.<span class="text-yellow-300">println</span>(<span class="text-green-300">"Thread is running..."</span>);
    }
}

<span class="text-blue-300">MyThread</span> thread = <span class="text-purple-300">new</span> <span class="text-blue-300">MyThread</span>();
thread.<span class="text-yellow-300">start</span>();</pre>
                        </div>
                    </div>
                    
                    <div>
                        <div class="flex items-center mb-2">
                            <div class="bg-indigo-500 w-3 h-3 rounded-full mr-2"></div>
                            <h4 class="font-medium text-gray-800">实现 Runnable 接口</h4>
                        </div>
                        <p class="text-gray-600 text-sm mb-2">通过实现 <code>Runnable</code> 接口并重写 <code>run()</code> 方法，定义线程执行的任务。此方式的好处是可以继承其他类。</p>
                        <div class="code-block p-4 rounded-lg">
                            <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-purple-300">class</span> <span class="text-blue-300">MyRunnable</span> <span class="text-purple-300">implements</span> <span class="text-blue-300">Runnable</span> {
    <span class="text-blue-300">@Override</span>
    <span class="text-purple-300">public</span> <span class="text-blue-300">void</span> <span class="text-yellow-300">run</span>() {
        <span class="text-blue-300">System</span>.<span class="text-yellow-300">out</span>.<span class="text-yellow-300">println</span>(<span class="text-green-300">"Runnable is running..."</span>);
    }
}

<span class="text-blue-300">MyRunnable</span> runnable = <span class="text-purple-300">new</span> <span class="text-blue-300">MyRunnable</span>();
<span class="text-blue-300">Thread</span> thread = <span class="text-purple-300">new</span> <span class="text-blue-300">Thread</span>(runnable);
thread.<span class="text-yellow-300">start</span>();</pre>
                        </div>
                    </div>
                </div>

                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-teal-100 text-teal-800 px-3 py-1 rounded-full mr-3 text-sm">3.2</span>
                        线程池的使用
                    </h3>
                    <p class="text-gray-700 mb-4">
                        线程池是 Java 提供的一个用于管理线程的机制，它能够有效地控制线程的创建与销毁，避免频繁的线程创建带来的性能开销。Java 提供了 <code>Executor</code> 框架来管理线程池。使用线程池可以复用线程，减少上下文切换的开销，提高性能。
                    </p>
                    
                    <div class="code-block p-4 rounded-lg mb-6">
                        <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-blue-300">ExecutorService</span> executor = <span class="text-blue-300">Executors</span>.<span class="text-yellow-300">newFixedThreadPool</span>(<span class="text-orange-300">10</span>);
executor.<span class="text-yellow-300">submit</span>(() <span class="text-purple-300">-></span> {
    <span class="text-blue-300">System</span>.<span class="text-yellow-300">out</span>.<span class="text-yellow-300">println</span>(<span class="text-green-300">"Task is running..."</span>);
});</pre>
                    </div>
                    
                    <div class="bg-teal-50 p-4 rounded-lg border-l-4 border-teal-400">
                        <div class="flex">
                            <i class="fas fa-lightbulb text-teal-500 mt-1 mr-3"></i>
                            <div>
                                <p class="text-teal-800 font-medium mb-1">线程池最佳实践</p>
                                <ul class="text-teal-700 text-sm list-disc list-inside">
                                    <li>根据任务类型(I/O密集型或CPU密集型)设置合适的线程池大小</li>
                                    <li>考虑使用带缓冲的队列</li>
                                    <li>为线程池设置合理的拒绝策略</li>
                                    <li>监控线程池的运行状态</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 4 -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-yellow-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">4. 线程安全问题与解决方案</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-yellow-100 text-yellow-800 px-3 py-1 rounded-full mr-3 text-sm">4.1</span>
                        线程安全的定义
                    </h3>
                    <p class="text-gray-700">
                        线程安全是指多个线程在并发访问时，能够正确地访问共享资源，不会产生竞争条件和数据不一致的情况。线程安全的程序能够保证多个线程在执行时不会破坏程序的正确性。
                    </p>
                    
                    <div class="bg-amber-50 p-4 rounded-lg border-l-4 border-amber-400 mt-6">
                        <div class="flex">
                            <i class="fas fa-shield-alt text-amber-500 mt-1 mr-3"></i>
                            <p class="text-amber-800">
                                <strong>线程安全的三个特性：</strong> 原子性、可见性、有序性。任何线程安全机制都需要保证这三个特性。
                            </p>
                        </div>
                    </div>
                </div>

                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-orange-100 text-orange-800 px-3 py-1 rounded-full mr-3 text-sm">4.2</span>
                        解决线程安全问题的方式
                    </h3>
                    
                    <div class="space-y-4">
                        <div>
                            <div class="flex items-center mb-2">
                                <div class="bg-orange-500 w-3 h-3 rounded-full mr-2"></div>
                                <h4 class="font-medium text-gray-800">同步机制</h4>
                            </div>
                            <p class="text-gray-600 text-sm mb-2">使用 <code>synchronized</code> 关键字对共享资源进行加锁，保证每次只有一个线程能够访问共享资源。<code>synchronized</code> 可以用于方法或代码块。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-purple-300">synchronized</span> (lock) {
    <span class="text-gray-400">// critical section</span>
}</pre>
                            </div>
                        </div>
                        
                        <div>
                            <div class="flex items-center mb-2">
                                <div class="bg-red-500 w-3 h-3 rounded-full mr-2"></div>
                                <h4 class="font-medium text-gray-800">锁机制</h4>
                            </div>
                            <p class="text-gray-600 text-sm mb-2">使用 <code>ReentrantLock</code> 等锁机制来控制对共享资源的访问。相比于 <code>synchronized</code>，<code>ReentrantLock</code> 提供了更多的灵活性，如可中断锁、定时锁等。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-blue-300">ReentrantLock</span> lock = <span class="text-purple-300">new</span> <span class="text-blue-300">ReentrantLock</span>();
lock.<span class="text-yellow-300">lock</span>();
<span class="text-purple-300">try</span> {
    <span class="text-gray-400">// critical section</span>
} <span class="text-purple-300">finally</span> {
    lock.<span class="text-yellow-300">unlock</span>();
}</pre>
                            </div>
                        </div>
                        
                        <div>
                            <div class="flex items-center mb-2">
                                <div class="bg-green-500 w-3 h-3 rounded-full mr-2"></div>
                                <h4 class="font-medium text-gray-800">原子操作</h4>
                            </div>
                            <p class="text-gray-600 text-sm mb-2">对于一些简单的操作，可以使用 <code>Atomic</code> 类（如 <code>AtomicInteger</code>）来保证操作的原子性，避免使用传统的锁机制。</p>
                            <div class="code-block p-4 rounded-lg">
                                <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-blue-300">AtomicInteger</span> count = <span class="text-purple-300">new</span> <span class="text-blue-300">AtomicInteger</span>(<span class="text-orange-300">0</span>);
count.<span class="text-yellow-300">incrementAndGet</span>();</pre>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 5 -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-red-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">5. 死锁与避免死锁</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-red-100 text-red-800 px-3 py-1 rounded-full mr-3 text-sm">5.1</span>
                        死锁的定义
                    </h3>
                    <p class="text-gray-700">
                        死锁是指多个线程在执行过程中，由于争夺资源而造成的一种相互等待的现象。死锁发生时，线程之间相互等待，导致程序无法继续执行，造成严重的性能问题。
                    </p>
                    
                    <h3 class="text-xl font-semibold text-gray-800 mt-6 mb-4 flex items-center">
                        <span class="bg-pink-100 text-pink-800 px-3 py-1 rounded-full mr-3 text-sm">5.2</span>
                        死锁的产生条件
                    </h3>
                    <p class="text-gray-700 mb-4">
                        死锁的产生通常满足以下四个条件：
                    </p>
                    <ul class="space-y-2 text-gray-700">
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white text-xs font-bold px-2 py-1 rounded-full mr-3">1</span>
                            <span><strong>互斥条件：</strong>一个资源每次只能被一个线程占用。</span>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white text-xs font-bold px-2 py-1 rounded-full mr-3">2</span>
                            <span><strong>请求与保持条件：</strong>一个线程在请求资源时，已保持对其他资源的占用。</span>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white text-xs font-bold px-2 py-1 rounded-full mr-3">3</span>
                            <span><strong>不剥夺条件：</strong>线程持有的资源在没有使用完之前，不会被其他线程强行剥夺。</span>
                        </li>
                        <li class="flex items-start">
                            <span class="bg-red-500 text-white text-xs font-bold px-2 py-1 rounded-full mr-3">4</span>
                            <span><strong>循环等待条件：</strong>一组线程形成循环等待关系。</span>
                        </li>
                    </ul>
                </div>

                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-green-100 text-green-800 px-3 py-1 rounded-full mr-3 text-sm">5.3</span>
                        避免死锁的策略
                    </h3>
                    
                    <div class="space-y-4">
                        <div class="flex items-start">
                            <div class="bg-green-100 p-2 rounded-full mr-3 mt-1">
                                <i class="fas fa-ban text-green-600 text-sm"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-gray-800 mb-1">避免循环等待</h4>
                                <p class="text-gray-600 text-sm">通过设计系统的资源分配顺序，避免线程之间形成循环等待。例如，可以约定所有线程必须按照相同的顺序获取锁。</p>
                            </div>
                        </div>
                        
                        <div class="flex items-start">
                            <div class="bg-blue-100 p-2 rounded-full mr-3 mt-1">
                                <i class="fas fa-clock text-blue-600 text-sm"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-gray-800 mb-1">使用定时锁</h4>
                                <p class="text-gray-600 text-sm">使用定时锁（如 <code>ReentrantLock</code> 的 <code>tryLock()</code> 方法）来避免长时间等待锁。如果线程在指定时间内无法获取锁，可以放弃或执行其他操作。</p>
                            </div>
                        </div>
                        
                        <div class="flex items-start">
                            <div class="bg-purple-100 p-2 rounded-full mr-3 mt-1">
                                <i class="fas fa-boxes text-purple-600 text-sm"></i>
                            </div>
                            <div>
                                <h4 class="font-medium text-gray-800 mb-1">资源请求时一次性获取所有资源</h4>
                                <p class="text-gray-600 text-sm">线程在请求资源时，尽量一次性获取所有需要的资源，避免占用部分资源时再去请求其他资源。这可以减少死锁的可能性。</p>
                            </div>
                        </div>
                    </div>
                    
                    <div class="bg-gray-50 p-4 rounded-lg border border-gray-200 mt-6">
                        <div class="flex items-center">
                            <i class="fas fa-code text-gray-400 mr-3"></i>
                            <p class="text-gray-600 text-sm">
                                <strong>示例：</strong>使用<code>tryLock()</code>避免死锁
                            </p>
                        </div>
                        <div class="code-block p-4 rounded-lg mt-2">
                            <pre class="text-gray-300 font-mono text-sm overflow-x-auto">
<span class="text-blue-300">ReentrantLock</span> lock1 = <span class="text-purple-300">new</span> <span class="text-blue-300">ReentrantLock</span>();
<span class="text-blue-300">ReentrantLock</span> lock2 = <span class="text-purple-300">new</span> <span class="text-blue-300">ReentrantLock</span>();

<span class="text-purple-300">if</span> (lock1.<span class="text-yellow-300">tryLock</span>() && lock2.<span class="text-yellow-300">tryLock</span>()) {
    <span class="text-purple-300">try</span> {
        <span class="text-gray-400">// 临界区代码</span>
    } <span class="text-purple-300">finally</span> {
        lock2.<span class="text-yellow-300">unlock</span>();
        lock1.<span class="text-yellow-300">unlock</span>();
    }
}</pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 6 -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">6. 多线程的常见问题与调优</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-indigo-100 text-indigo-800 px-3 py-1 rounded-full mr-3 text-sm">6.1</span>
                        线程上下文切换
                    </h3>
                    <p class="text-gray-700 mb-4">
                        线程上下文切换是操作系统为了支持多任务而保存和恢复线程状态的过程。频繁的上下文切换会带来额外的开销，尤其是在多核系统中，当线程数超过 CPU 核心数时，上下文切换的成本将非常高。
                    </p>
                    
                    <div class="bg-indigo-50 p-4 rounded-lg border-l-4 border-indigo-400">
                        <div class="flex">
                            <i class="fas fa-tools text-indigo-500 mt-1 mr-3"></i>
                            <div>
                                <p class="text-indigo-800 font-medium mb-1">优化方法</p>
                                <ul class="text-indigo-700 text-sm list-disc list-inside">
                                    <li>减少线程的数量，避免过度并发</li>
                                    <li>使用线程池来重用线程，减少线程的创建和销毁</li>
                                    <li>通过负载均衡来合理分配任务，减少线程的竞争</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>

                <div>
                    <h3 class="text-xl font-semibold text-gray-800 mb-4 flex items-center">
                        <span class="bg-purple-100 text-purple-800 px-3 py-1 rounded-full mr-3 text-sm">6.2</span>
                        内存屏障与缓存一致性
                    </h3>
                    <p class="text-gray-700 mb-4">
                        多核处理器通常会在每个核心上维护缓存，当多个线程访问共享数据时，不同核心的缓存可能出现不一致，导致数据错误。Java 使用内存屏障和 <code>volatile</code> 关键字来确保数据的一致性。
                    </p>
                    
                    <div class="bg-purple-50 p-4 rounded-lg border-l-4 border-purple-400">
                        <div class="flex">
                            <i class="fas fa-tools text-purple-500 mt-1 mr-3"></i>
                            <div>
                                <p class="text-purple-800 font-medium mb-1">优化方法</p>
                                <ul class="text-purple-700 text-sm list-disc list-inside">
                                    <li>使用 <code>volatile</code> 关键字保证共享变量的可见性</li>
                                    <li>使用 <code>synchronized</code> 或 <code>Lock</code> 来确保线程间的顺序性和原子性</li>
                                    <li>考虑使用 <code>Atomic</code> 类替代传统的同步机制</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 7 -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-teal-600 mr-4"></div>
                <h2 class="text-3xl font-bold text-gray-800">7. 多线程编程中的最佳实践</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <div class="mb-6">
                        <h3 class="text-xl font-semibold text-gray-800 mb-3 flex items-center">
                            <span class="bg-teal-100 text-teal-800 px-3 py-1 rounded-full mr-3 text-sm">7.1</span>
                            合理使用线程池
                        </h3>
                        <p class="text-gray-700">
                            线程池可以避免频繁创建和销毁线程的开销，提高系统的性能。在使用线程池时，应该根据实际需求合理设置线程池的大小，避免资源浪费或线程池耗尽。
                        </p>
                    </div>
                    
                    <div class="mb-6">
                        <h3 class="text-xl font-semibold text-gray-800 mb-3 flex items-center">
                            <span class="bg-blue-100 text-blue-800 px-3 py-1 rounded-full mr-3 text-sm">7.2</span>
                            避免共享数据
                        </h3>
                        <p class="text-gray-700">
                            尽量避免多个线程共享同一数据，如果必须共享，使用合适的同步机制来保证数据的一致性。
                        </p>
                    </div>
                </div>

                <div>
                    <div class="mb-6">
                        <h3 class="text-xl font-semibold text-gray-800 mb-3 flex items-center">
                            <span class="bg-orange-100 text-orange-800 px-3 py-1 rounded-full mr-3 text-sm">7.3</span>
                            线程的优先级
                        </h3>
                        <p class="text-gray-700">
                            合理设置线程的优先级，有助于高优先级任务的及时执行。然而，线程的优先级并非在所有操作系统中都能得到有效支持，因此在多平台开发时，应该小心使用。
                        </p>
                    </div>
                    
                    <div>
                        <h3 class="text-xl font-semibold text-gray-800 mb-3 flex items-center">
                            <span class="bg-green-100 text-green-800 px-3 py-1 rounded-full mr-3 text-sm">7.4</span>
                            适时释放资源
                        </h3>
                        <p class="text-gray-700">
                            多线程程序中，线程间的资源竞争可能会导致性能问题。因此，开发者应在适当的时候释放无用资源，避免线程和内存泄漏。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Summary Section -->
        <section class="bg-white p-8 rounded-xl shadow-md mb-16">
            <div class="flex items-center mb-6">
                <i class="fas fa-star text-yellow-400 text-2xl mr-4"></i>
                <h2 class="text-2xl font-bold text-gray-800">关键知识点总结</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="border-l-4 border-indigo-500 pl-4">
                    <h3 class="text-lg font-semibold text-gray-800 mb-2">并发编程核心</h3>
                    <ul class="space-y-2 text-gray-700">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-indigo-500 mt-1 mr-2 text-sm"></i>
                            <span>并发是逻辑上的同时执行，多线程是实现并发的一种方式</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-indigo-500 mt-1 mr-2 text-sm"></i>
                            <span>多线程能提高响应性、资源利用率和系统吞吐量</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-indigo-500 mt-1 mr-2 text-sm"></i>
                            <span>线程安全、死锁和上下文切换是多线程的主要挑战</span>
                        </li>
                    </ul>
                </div>
                
                <div class="border-l-4 border-purple-500 pl-4">
                    <h3 class="text-lg font-semibold text-gray-800 mb-2">最佳实践</h3>
                    <ul class="space-y-2 text-gray-700">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-purple-500 mt-1 mr-2 text-sm"></i>
                            <span>优先使用线程池管理线程，而非直接创建线程</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-purple-500 mt-1 mr-2 text-sm"></i>
                            <span>尽量减少共享数据，必须共享时使用适当的同步机制</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-purple-500 mt-1 mr-2 text-sm"></i>
                            <span>理解并避免死锁的四个必要条件</span>
                        </li>
                    </ul>
                </div>
            </div>
            
            <div class="mt-8 bg-blue-50 p-4 rounded-lg">
                <div class="flex items-center">
                    <i class="fas fa-book-open text-blue-500 mr-3 text-xl"></i>
                    <div>
                        <h3 class="text-lg font-semibold text-gray-800 mb-1">扩展学习资源</h3>
                        <p class="text-gray-600 text-sm">
                            《Java并发编程实战》、JUC包源码分析、并发设计模式等
                        </p>
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-10 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white">技术小馆</h3>
                    <p class="text-gray-400 mt-1">探索编程世界的奥秘</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition duration-300">
                        <i class="fas fa-external-link-alt mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-sm text-gray-400">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'dark',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // 平滑滚动
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
        
        // 卡片悬停效果增强
        const cards = document.querySelectorAll('.card-hover');
        cards.forEach(card => {
            card.addEventListener('mouseenter', () => {
                card.classList.add('shadow-lg');
            });
            card.addEventListener('mouseleave', () => {
                card.classList.remove('shadow-lg');
            });
        });
    </script>
</body>
</html>
```